Methods and apparatus for event logging in an information network

ABSTRACT

Methods and apparatus for logging, analysis, and reporting of events such as reboots in a client device (e.g., consumer premises equipment in a cable network) using applications. In one aspect, an improved event logging and monitoring system is provided within the device with which the application(s) can interface to record event or error data. In one exemplary embodiment, the client device comprises a digital set-top box having Java-enabled middleware adapted to implement the various functional aspects of the event logging system, which registers to receive event notifications (including resource exhaustion data) from other applications running on the device. The network operator can also optionally control the operation of the logging system remotely via a network agent. Improved client device and network configurations, as well as methods of operating these systems, are also disclosed.

PRIORITY AND RELATED APPLICATIONS

This application is a continuation of and claims priority to co-owned and U.S. patent application Ser. No. 13/236,487 of the same title filed Sep. 19, 2011 (issuing as U.S. Pat. No. 8,321,723 on Nov. 27, 2012), which is a continuation of and claims priority to co-owned U.S. Pat. No. 8,046,636 of the same title and issued on Oct. 25, 2011, which is a continuation of and claims priority to co-owned U.S. Pat. No. 7,698,606 of the same title and issued on Apr. 13, 2010, and which is a divisional of co-owned U.S. Pat. No. 7,266,726 of the same title and issued on Sep. 4, 2007, each of the foregoing being incorporated herein by reference in its entirety. This application is also related to co-owned U.S. Pat. No. 8,024,607 of the same title and issued on Sep. 20, 2011, which also incorporated herein by reference in its entirety.

COPYRIGHT

A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

1. Field of Invention

The present invention relates generally to the field of software applications used on an information network (such as a cable television network), and specifically to the logging, analysis, and control of events occurring on electronic devices used in the network during operation of the software.

2. Description of Related Technology

Software applications are well known in the prior art. Such applications may run on literally any type of electronic device, and may be distributed across two or more locations or devices connected by a network. Often, a so-called “client/server” architecture is employed, where one or more portions of applications disposed on client or consumer premises devices (e.g., PCs, PDAs, digital set-top boxes {DSTBs}, hand-held computers, etc.) are operatively coupled and in communication with other (server) portions of the application. Such is the case in the typical hybrid fiber coax (HFC) or satellite content network, wherein consumer premises equipment or CPE (e.g., DSTBs or satellite receivers) utilize the aforementioned “client” portions of applications to communicate with their parent server portions in order to provide downstream and upstream communications and data/content transfer.

Digital TV (DTV) is an emerging technology which utilizes digitized and compressed data formats (e.g., MPEG) for content transmission, as compared to earlier analog “uncompressed” approaches (e.g., NTSC). The DTV content may be distributed across any number of different types of bearer media or networks with sufficient bandwidth, including HFC, satellite, wireless, or terrestrial. DTV standards such as the OpenCable Application Platform middleware specification (e.g., Version 1.0, and incipient Version 2.0) require that applications be downloaded to CPE from the bearer or broadcast network in real-time. The OCAP specification is a middleware software layer specification intended to enable the developers of interactive television services and applications to design such products so that they will run successfully on any cable television system in North America, independent of set-top or television receiver hardware or operating system software choices.

Due to the broad variety of applications which can be downloaded over cable networks, and the broad variety of different CPE hardware and middleware that can receive such applications, application run-time and other software errors are somewhat inevitable. These errors can result in both significant frustration for the consumer, and the generation of many unnecessary service calls from the cable systems operator or other service provider. These deficiencies stem largely from the inability of existing cable/CPE devices to (i) log, analyze, and recover from fairly routine or non-critical errors; and (ii) communicate with the cable systems operator. Specifically, a network provider must be able to process events occurring within the CPE connected to their networks, including identifying (and ideally diagnosing and correcting) any errors. This CPE may include both leased equipment and retail consumer electronic equipment, and hence any corrective system must be adapted to interface with a variety of different equipment.

One type of error or event which can occur in cable network CPE is what is generally referred to as “resource exhaustion”. This term is applied to a group of different circumstances wherein one or more resources within the CPE (such as memory, CPU capacity, etc.) are at or near exhaustion, thereby indicating an incipient or prospective error condition within an application. As is well known, when resources such as memory become exhausted within an OCAP compliant Host device (e.g., set-top box, integrated TV), the application manager within the OCAP system will begin destroying applications starting with the lowest priority application. Hence, the OCAP-compliant CPE employs a priority-based system of resource self-preservation. However, such systems are generally not capable of (uniquely) dealing with different types of resource exhaustion, logging data relating to the exhaustion event(s), or initiating corrective action for other types of events occurring within the CPE (such as thrown but uncaught Java exceptions), or reboot events which are not initiated by the middleware. Accordingly, the OCAP-complaint prior art CPE is generally not as robust as it could be, and does not afford the level of control over the CPE operations during error conditions that is desired by cable network operators.

A variety of other approaches to error logging and handling within computer systems are taught in the prior art. These approaches generally range from bit-level systems such as those used in semiconductor applications, to higher-level functional or behavior logging systems for networked computers. For example, U.S. Pat. No. 3,999,051 to Petschauer issued Dec. 21, 1976 and entitled “Error logging in semiconductor storage units” discloses a maintenance procedure comprising a method of and an apparatus for storing information identifying the location of one or more defective bits, i.e., a defective memory element, a defective storage device or a failure, in a single-error-correcting semiconductor main storage unit (MSU) comprised of a plurality of large scale integrated (LSI) bit planes. The method utilizes an error logging store (ELS) comprised of 128 word-group-associated memory registers. A defective device counter (DDC) counts the set tag bits in the ELS and is utilized by the machine operator to schedule preventative maintenance of the MSU by replacing the defective bit planes. By statistically determining the number of allowable failures, i.e., the number of correctable failures that may occur before the expected occurrence of a noncorrectable double bit error, preventative maintenance may be scheduled only as required by the particular MSU.

U.S. Pat. No. 4,339,657 to Larson, et al. issued Jul. 13, 1982 and entitled “Error logging for automatic apparatus” discloses methods and apparatus for error logging by integrating errors over a given number of operations that provides long memory and fast recovery. Errors integrated over a selected number of associated operations are compared to a criterion. An exception is logged each time the number of errors is not less than the criterion but if the number of errors is less than the criterion, the exception log is cleared.

U.S. Pat. No. 4,604,751 to Aichelmann, Jr., et al. issued Aug. 5, 1986 and entitled “Error logging memory system for avoiding miscorrection of triple errors” discloses apparatus by which miscorrection of triple errors is avoided in a memory system by providing a double bit error logging technique. The address of each fetched word is logged in which a double bit error is detected. The address of each fetched word in which a single bit error is detected is compared with all logged addresses. If a coincidence is found between the compared addresses, a triple bit error alerting signal is generated and error recovery procedures are initiated.

U.S. Pat. No. 5,121,475 to Child, et al. issued Jun. 9, 1992 and entitled “Methods of dynamically generating user messages utilizing error log data with a computer system” discloses methods of error logging and correction in a communications software system. An error log request is generated by a component of the system; the error log request is analyzed and compared to entries in one of a plurality of records in a message look-up table. If there is a match between the fields of the error log request and selected entries of a record in the look-up table, a user message request is generated which facilitates the display of a pre-existing user friendly message as modified with data included in the generated user message request.

U.S. Pat. No. 5,155,731 to Yamaguchi issued Oct. 13, 1992 and entitled “Error logging data storing system” discloses an error logging data storing system containing a first storing unit for storing error logging data corresponding to an error of high importance, a second storing unit for storing error logging data corresponding to an error of either high or low importance. A first indicating unit indicates whether or not the first storing unit is occupied by error logging data the diagnosing operation of which is not completed. A second indicating unit indicates whether or not the second storing unit is occupied by error logging data the diagnosing operation of which is not completed. A storage control unit stores error logging data corresponding to an error of high importance in the second storing unit when the first indicating unit indicates that the first storing unit is occupied by error logging data the diagnosing operation of which is not completed and the second indicating unit indicates that the second storing unit is not occupied by error logging data the diagnosing operation of which is not completed.

U.S. Pat. No. 5,245,615 to Treu issued Sep. 14, 1993 and entitled “Diagnostic system and interface for a personal computer” discloses a personal computer having a NVRAM comprising an error log for storing predetermined error log information at predetermined locations therein. The information is accessible by various programs such as a POST program, a diagnostics program, and an operating system program. Access is made by BIOS interrupt calls through a BIOS interface. The NVRAM also stores vital product data and system setup data.

U.S. Pat. No. 5,463,768 to Cuddihy, et al. issued Oct. 31, 1995 and entitled “Method and system for analyzing error logs for diagnostics” discloses an error log analysis system comprising a diagnostic unit and a training unit. The training unit includes a plurality of historical error logs generated during abnormal operation or failure from a plurality of machines, and the actual fixes (repair solutions) associated with the abnormal events or failures. A block finding unit identifies sections of each error log that are in common with sections of other historical error logs. The common sections are then labeled as blocks. Each block is then weighted with a numerical value that is indicative of its value in diagnosing a fault. In the diagnostic unit, new error logs associated with a device failure or abnormal operation are received and compared against the blocks of the historical error logs stored in the training unit. If the new error log is found to contain block(s) similar to the blocks contained in the logs in the training unit, then a similarity index is determined by a similarity index unit, and solution(s) is proposed to solve the new problem. After a solution is verified, the new case is stored in the training unit and used for comparison against future new cases.

U.S. Pat. No. 5,790,779 to Ben-Natan, et al. issued Aug. 4, 1998 and entitled “Method and system for consolidating related error reports in a computer system” discloses a method and system for consolidating related error reports. In a preferred embodiment, a facility preferably implemented in software (“the facility”) receives error reports and success reports generated by programs. When the facility receives a novel error report specifying an error source for which no error state is set, it sets an error state corresponding to the error report. The facility also preferably generates a consolidated error report at this point, which is delivered to a error state reporting subsystem. The error state reporting subsystem may add the consolidated error report to an error log and/or display it to a user. When the facility receives a redundant error report specifying an error source for which an error state is already set, the facility preferably does not set a new error state, nor does it generate a consolidated error report. When the facility receives a success report specifying an error source, it clears any error states that are set for the specified error source, and preferably generates a consolidated success report. The performance of the facility is preferably optimized by processing success reports asynchronously.

U.S. Pat. No. 5,862,316 to Hagersten, et al. issued Jan. 19, 1999 and entitled “Multiprocessing system having coherency-related error logging capabilities” discloses protocol agents involved in the performance of global coherency activity that detect errors with respect to the activity being performed. The errors are logged by a computer system such that diagnostic software may be executed to determine the error detected and to trace the error to the erring software or hardware. In particular, information regarding the first error to be detected is logged. Subsequent errors may receive more or less logging depending upon programmable configuration values. Additionally, those errors which receive full logging may be programmably selected via error masks. The protocol agents each comprise multiple independent state machines which independently process requests. If the request which a particular state machine is processing results in an error, the particular state machine may enter a freeze state. Information regarding the request which is collected by the state machine may thereby be saved for later access. A state machine freezes upon detection of the error if a maximum number of the multiple state machines are not already frozen and the aforementioned error mask indicates that full error logging is employed for the detected error. Therefore, at least a minimum number of the multiple state machines remain functioning even in the presence of a large number of errors. Still further, prior to entering the freeze state, the protocol state machines may transition through a recovery state in which resources not used for error logging purposes are freed from the erring request.

U.S. Pat. No. 6,381,710 to Kim issued Apr. 30, 2002 and entitled “Error logging method utilizing temporary defect list” discloses an error logging method utilizing a temporary defect list to store errors produced at or above a predetermined occurrence frequency during a defect detecting test. The method includes the steps of: determining whether an error is recorded on a temporary defect list, determining whether the error is recorded on an error frequency list when the error is not recorded on the temporary defect list, adding the error to the error frequency list if the error is not recorded on the error frequency list, increasing the occurrence frequency of the error if the error is on the error frequency list, and adding the error to the temporary defect list if the error has an occurrence frequency greater than or equal to a threshold value established as a standard for classifying an error as a defect. The temporary defect list can be used as a final error list, and thereby reduce memory requirements.

U.S. Pat. No. 6,532,552 to Benignus, et al. issued Mar. 11, 2003 and entitled “Method and system for performing problem determination procedures in hierarchically organized computer systems” discloses a method and system for performing problem determination procedures in a hierarchically organized computer system. The hardware components of the data processing system are interconnected in a manner in which the components are organized in a logical hierarchy. A hardware-related error occurs, and the error is logged into an error log file. At some point in time, a diagnostics process is initiated in response to the detection of the error. The logged error may implicate a particular hardware component, and the hardware component of the data processing system is analyzed using a problem determination procedure. In response to a determination that the hardware component does not have a problem, the logically hierarchical parent hardware component of the hardware component is selected for analysis. The logically hierarchical parent hardware component is then analyzed using a problem determination procedure. The method continues to analyze the logically hierarchical parent components until the root component is reached or until a faulty component is found.

U.S. Pat. No. 6,505,298 to Cerbini, et al. issued Jan. 7, 2003 and entitled “System using an OS inaccessible interrupt handler to reset the OS when a device driver failed to set a register bit indicating OS hang condition” discloses a method and system for providing a reset after an operating system (OS) hang condition in a computer system, the computer system including an interrupt handier not accessible by the OS. The method includes determining if an interrupt has been generated by a watchdog timer; monitoring for an OS hang condition by the interrupt handler if the interrupt has been generated and after it is known that the OS is operating; and resetting the OS if a device driver within the OS has not set a bit in a register, the bit for indicating that the OS is operating. The method and system in accordance with the present invention uses existing hardware and software within a computer system to reset the OS. The invention uses a method by which a critical hardware watchdog periodically wakes a critical interrupt handler of the computer system. The critical interrupt handler determines if the OS is in a hang condition by polling a share hardware register that a device driver, running under the OS, will set periodically. If the critical interrupt handler does not see that the device driver has set the register bit, it will assume the OS has hung and will reset the system. In addition, the critical interrupt handler will store the reset in non-volatile memory. The reset can be logged into the system error log. Because the method and system in accordance with the invention uses existing hardware and software within the computer system, instead of requiring an additional processor, it is ostensibly cost efficient to implement while also providing a reset of the OS without human intervention.

United States Patent Publication No. 20010007138 to Iida, et al. published Jul. 5, 2001 and entitled “Method and system for remote management of processor, and method and system for remote diagnosis of image output apparatus” discloses a method and system for remote management of processors and a method and system for remote diagnosis of processors such as image output apparatus. Operation information about contents of operation performed by a processor during an operational preset period or a preset number of executions of processing is recorded. An operation log is formed by combining the operation information and is transferred to a remote management apparatus connected to the processor by a communication line. The remote management apparatus performs remote management of the condition of the processor on the basis of the transmitted operation log. An error log containing information about occurrences of errors having occurred in the processor is also formed and transferred to the remote management apparatus.

United States Patent Publication No. 20020083214 to Heisig, et al. published Jun. 27, 2002 and entitled “Protocol adapter framework for integrating non-HOP applications into an object server container” discloses a method and apparatus for providing access to objects and methods via arbitrary remote protocols in a computer with object server. This includes a mechanism known as the protocol adapter framework that allows protocol adapters to manage remote socket sessions, encrypt communication on this session, translate text to the local character set, perform security validation of the remote user, log incoming work requests, classify the incoming work request for differentiated service purposes, and queue the work for execution. Also, included is a mechanism to invoke the protocol adapter in order to manipulate output from the execution of a method on a server object and send it back to the original requester. This allows the implementers of objects and methods that reside in the object server rather than the owner of the object server to provide a protocol adapter that allows communication with remote clients using any arbitrary protocol that the object implementer deems appropriate. In this way, the object implementer can enjoy benefits such as differentiated service, workload recording, server object process management, process isolation, error logging, systems management and transactional services of running objects in a robust object server container.

United States Patent Application Publication No. 20020144193 to Hicks, et al. published Oct. 3, 2002 and entitled “Method and system for fault isolation methodology for I/O unrecoverable, uncorrectable error” discloses a method and system for managing uncorrectable data error conditions from an I/O subsystem as the UE passes through a plurality of devices in a central electronic complex (CEC). The method and system comprises detecting a I/O UE by at least one device in the CEC; and providing an SUE-RE (Special Uncorrectable Data Error-Recoverable Error) attention signal by at least one device to a diagnostic system that indicates the I/O UE condition. The method and system further includes analyzing the SUE-RE attention signal by the diagnostic system to produce an error log with a list of failing parts and a record of the log. The invention provides a fault isolation methodology and algorithm, which allows for the determination of an error source and provides appropriate service action if and when the system fails to recover from the UE condition.

United States Patent Application Publication No. 20030041291 to Hashem, et al. published Feb. 27, 2003 and entitled “Method and system for tracking errors” discloses a system and method for tracking errors, the system residing on a user's desktop communicating with a central database over a network. The system comprises an error log including error recording tools for enabling the user to record an error; error resolution tools for enabling the user to resolve the error; and error follow-up tools for enabling a user to follow up on resolved errors; error reporting tools for enabling a user to generate error reports from the user's desktop; and communication tools for enabling the user to transmit logged errors to the central database and to receive reports generate from errors logged in the central database.

United States Patent Application Publication No. 20030056155 to Austen, et al. published Mar. 20, 2003 and entitled “Method and apparatus for filtering error logs in a logically partitioned data processing system” discloses a method, apparatus, and computer implemented instructions for reporting errors to a plurality of partitions. Responsive to detecting an error log, an error type for the error log is identified. If the error log is identified as a regional error log, an identification of each partition to receive the error log is made. Then, the error log is reported to each partition that has been identified to receive the error log.

United States Patent Application Publication No. 20030105995 to Schroath, et al. published Jun. 5, 2003 and entitled “Method and apparatus for rebooting a printer” discloses detection and logging of printer errors in an error log. If the same printer error has occurred within a predetermined time period, an error message is generated on the printer's control panel and a network administrator is notified of the printer errors. If the same printer error has not occurred within the predetermined time period, the printer is rebooted. If the same printer error has occurred a predetermined number of consecutive times, an error message is generated on the printer's control panel and a network administrator is notified of the printer errors. If the same printer error has not occurred a predetermined number of times, the printer is rebooted.

United States Patent Application Publication No. 20030140285 to Wilkie published Jul. 24, 2003 and entitled “Processor internal error handling in an SMP server” discloses a system and method for handling processor internal errors in a data processing system. The data processing system typically includes a set of main microprocessors that have access to a common system memory via a system bus. The system may further include a service processor that is connected to at least one of the main processors. In addition, the system includes internal error handling hardware configured to log and process internal errors generated by one or more of the main processors. The internal error hardware may include error detection logic configured to receive internal error signals from the main processors. By incorporating error logging and handling into dedicated hardware tied directly to the processor internal error signals, the invention ostensibly provides a lower cost, lower response latency mechanism for handling processor internal errors in high performance multiprocessor systems.

The well known Windows® NT operating system manufactured by Microsoft Corporation includes an error logging capability (“Event Viewer”) that may be used on, e.g., data networks including servers. The Event Viewer is a tool used to examine the three NT event logs: System, Security, and Application.

Each message within the Windows NT error logger has an event ID number. The maximum size of logs can be set, and overriding of log entries can be set depending on available disk space. System errors include: (i) Information—a significant event has occurred, but the event is not critical; (ii) Warning—this is a caution indication of a possible significant event which may or may not affect future operations; and (iii) Error—indicates a problem that has caused a failure of service.

Security Log errors include: (i) Success Audit—a successful audited security event has occurred; and (ii) Failure Audit—a failed audited security event has occurred.

The exemplary Windows NT Event viewer display includes information relating to the date, time, source, category, Event ID number, user, and computer to which a given error is related.

The Windows NT system uses a registry to locate files (.EXE or .DLL) that contain resource strings. RegisterEventSource and ReportEvent functions are provided to log messages to the event log service. The name specified as a parameter to RegisterEventSource must match the name of the key in the registry. With Windows NT, each system maintains its own log files; there is no central storage location.

Similarly, other third party products such as the EventReporter product sold by Adiscon GMbH monitors Windows NT/2000/XP/Server 2003 event logs and reports via syslog or email. Automated monitoring is provided to assist in early detection of problems on the network. For applications with a larger number of servers, a centralized log is maintained via syslog servers available for Windows, Unix, Linux and other operating systems. See also the “Snare” freeware product, which collects and processes Windows NT Event Log information from multiple event logs, and converts the information to tab or comma delimited text format and delivers it via UDP to a remote server.

A recently proposed Home Audio Video Interoperability (HAVi) specification is a consumer electronics (CE) industry standard design to permit digital audio and video devices that conform to this standard, regardless of manufacturer, to interoperate when connected via a network in the consumer's home. The HAVi standard (e.g., Version 1.1) uses the digital IEEE-1394 network standard for data transfer between devices and the 1394 A/VC protocols for device control.

The HAVi standard focuses on the transfer and processing (for example, recording and playback) of digital content between networked devices. HAVi-compliant devices will include not only familiar audio and video components but also cable modems, digital set-top boxes and “smart” storage devices such as personal video recorders (PVRs).

By employing modular software, the HAVi standard allows consumer electronics devices to identify themselves and what they can do when plugged into the host. The software functions by assigning a device control ID module to each hardware component of a system. Each system also is assigned multiple functional component modules, containing information about an individual device's capabilities, for example, whether a camcorder operates in DV format, or whether a receiver is designed to process AC3 audio.

All HAVi APIs involving messaging (e.g., those APIs where the Communication Type is “M” or “MB”) use a “status” structure consisting of two fields: an API code and an error code. Generally the different software elements will define their own error codes (see Annex 11.7 of HAVi Version 1.1). Additionally, there are several “general purpose” error codes that can be used by any software element. These general error codes are: (i) SUCCESS—the operation has succeeded (this is the normal return value in Status and not an error); (ii) EUNKNOWN_MESSAGE—the receiver of a HAVi message does not support the API indicated by the Operation Code contained within the message; (iii) EACCESS_VIOLATION—the caller of an API does not have permission to perform the operation; (iv) EUNIDENTIFIED_FAILURE—an error of unknown origin has occurred; (v) ERESERVED—the operation is refused because the FCM (or, in the case of a DCM, one of the FCMs involved in the DCM operation) is reserved by another software element and the invoking software element (possibly a secondary client) is not allowed to perform this operation; (vi) ENOT_IMPLEMENTED—the receiver of a HAVi message does not implement the optional API indicated by the Operation Code contained within the message; (vii) EINVALID_PARAMETER—one or more parameters in a HAVi message contain invalid values; (viii) ERESOURCE_LIMIT—the operation failed due to resource limitations at the destination device EPARAMETER_SIZE_LIMIT—one or more parameters in a HAVi message exceed their safe; (ix) parameter size limit and the receiver is unable to handle the parameter(s); (x) EINCOMPLETE_MESSAGE—the length of a HAVi message is shorter than the length required for compliant messages (using the Operation Code contained within the message); (xi) EINCOMPLETE_RESULT—one or more out parameters in a HAVi message are correct but incomplete. Note that this may only occur when one or more parameters are at least the safe parameter size; (xii) ELOCAL—the caller of a “local” API (as indicated in the “Services Provided” tables) is not on the same device as the provider of the API; and (xiii) ESTANDBY—the operation is refused because the target device is in standby state.

The error code appearing in the status value returned by a HAVi API is either: one of the general codes listed above, a Messaging System error code, or an API-specific error code (one that is listed in the “Error codes” section following the description of the API). If the Status value returned by a HAVi API contains one of the “general error codes” listed above (including SUCCESS), the API code is that used in invoking the API, otherwise it is the API code associated with the contained error (as identified in Annex 11.7). If the contained error is not listed in the “Error codes” section following the description of the API or the contained error has an invalid API code, the client of the API shall interpret the contained error as EUNIDENTIFIED_FAILURE. Therefore, if the client is a Java client, the corresponding messagesending method of the client class, server helper class (see section 7.3.8.1.2) or the SoftwareElement class throws HaviUnidentifiedFailureException in these cases.

In terms of resource limitations, some of the HAVi APIs have specifications that would allow unbounded sizes for some parameters. However, each FAV and IAV will only have a limited amount of memory. These limitations can differ from controller to controller and thus hamper interoperability between controllers. Therefore, for variable sized (input or output) parameters in HAVi APIs a “safe parameter size limit” is specified. Such limits indicate that compliant software elements will be able to handle messages where the size of the parameter in question is less than or equal to the safe parameter size limit. However, accepting parameters of size larger than the safe parameter size limit is allowed.

The safe parameter size limit puts a requirement to support the indicated parameter size at both sending and receiving sides. At the receiving side (in parameters for servers, out parameters for clients) this means being able to receive and handle. At the sending side (out parameters for servers, in parameters for clients) this means being able to construct and send.

The server may return the EPARAMETER_SIZE_LIMIT error if it cannot handle the request due to the safe parameter size of an in parameter being exceeded.

The server returns the EINCOMPLETE_RESULT error if the parameters it returns are valid but incomplete. Note that a server may only return this error when one or more of the parameters it returns are at least the safe parameter size.

The server returns ERESOURCE_LIMIT if it fails to process a request due to lack of resources. If the server generates an incomplete or potentially incomplete response, i.e., one where values of the out parameters are valid but may be incomplete, this error is not returned.

Despite the foregoing, no suitable methodology or architecture for both logging and responding to errors (such as repetitive boots or uncaught thrown Java exceptions) encountered during operation of networked systems has been disclosed under the prior art. This is particularly true in the context of leased set-top boxes and OpenCable compliant Host devices. Prior art solutions also do not provide the ability to (i) tailor delivery of error and reboot reports to a network agent, and (ii) transfer recovery of exhausted system resources from CPE manufacturer control to network operator control.

Accordingly, there is a need for improved apparatus and methods for providing error logging, diagnosis, operation, and control of applications within such networks. These improved apparatus and methods would meet these needs while also enabling compliance with industry standard requirements within the network.

SUMMARY OF THE INVENTION

The present invention addresses the foregoing needs by disclosing an improved error logging and response apparatus and associated methods.

In a first aspect of the invention, an improved method of operating client equipment in a content-based network is disclosed. The method generally comprises: generating first data relating to the operation of the equipment; receiving, at a first application, the first data; evaluating the first data; and selectively storing at least a portion of said first data within a storage device. In one exemplary embodiment, the client equipment comprises an OCAP-compliant set-top box or similar device having middleware comprising an event logging system registered to receive event notifications form other applications or hardware. The system is also adapted to evaluate the received notifications and classify them according to priority.

In a second aspect of the invention, an improved method of operating CPE having resources within a content-based network is disclosed. In one exemplary embodiment, the CPE includes an event logging system adapted to communicate with another network entity, and a plurality of software applications. The CPE evaluates the resource(s) using the logging system; and in response thereto selectively controls the operation of one or more of the applications, including selective destruction thereof based on depletion of the resources.

In a third aspect of the invention, fault-tolerant CPE adapted for coupling to a cable network is disclosed. The CPE generally comprises a monitor application running thereon and adapted to (i) detect at least one event relating to the operation of one or more software applications running thereon; (ii) selectively log data relating to the event for subsequent use; and (iii) control the operation of the CPE based at least in part on the detected event. In one exemplary embodiment, the monitor application is further adapted to communicate with an external entity such as a network agent. The monitor can both log errors for retrieval by the network agent, and selectively suspend or destroy software applications in order to mitigate resource depletion.

In a fourth aspect of the invention, an improved method of operating a cable network having a plurality of client devices operatively coupled thereto is disclosed, the method generally comprising: distributing at least one software application to each of the plurality of devices; providing at least one monitor entity to each of the devices; monitoring the operation of the software application(s) with respective ones of the monitor applications; detecting events associated with the operation of the software application(s); and responsive to such detecting, logging a plurality of data relating to the events within the devices for subsequent use. In the exemplary embodiment, the network comprises an HFC network with a plurality of DSTBs attached. A trusted monitor application implements the event logging system on the DSTBs, the logging system adapted to both selectively store data regarding various types of events, and provide access to the stored data to another agent on the network The monitor and agent may also institute corrective action for the event as required.

In a fifth aspect of the invention, an improved head-end apparatus for use in a cable network is disclosed. The apparatus generally comprises at least one server having a software process running thereon, the software process being adapted to selectively interface with at least one client device and retrieve logged error data therefrom. In the exemplary configuration, the head-end apparatus is disposed within an HFC network having an SMS, CMTS, and application distribution servers. The software process is adapted to communicate with the client device event logging system via either in-band or OOB channels.

In a sixth aspect of the invention, an improved error logging system adapted for use on a consumer electronics device is disclosed. The system generally comprises: an event registration entity; an event submission entity; an event database; a priority event reporting entity; a network retrieval entity; and a resource depletion registration entity. In one exemplary embodiment, the device comprises a set-top box having OCAP-compliant middleware comprised of at least a portion of the aforementioned functional entities. The entities comprise objects within a Java programming environment and the network retrieval entity comprises a portion of a client-server architecture by which the various entities in the logging system can be accessed and controlled remotely.

In a seventh aspect of the invention, a method of conducting business via a cable network having a plurality of client devices with event logging systems is disclosed. The method generally comprises: distributing a software application to the plurality of devices; running the software application; receiving an event notification via the event logging system; evaluating the notification to determine a corrective action; and selectively controlling a function within the device using the event logging system to implement at least a portion of the corrective action. In one embodiment, the event logging system comprises middleware running on the device, the middleware comprising a plurality of APIs. Selective control is accomplished via one or more of the APIs. The event logging system can also be selectively enabled based on one or more subscription policies in effect on the network for individual subscribers.

In another aspect, apparatus adapted for operation with a content delivery network is disclosed. In one embodiment, the apparatus includes: a network interface adapted for communication with the content delivery network; a digital processor; a storage device operatively coupled to the processor; middleware adapted to run on the processor; and software comprising a plurality of application programming interfaces (APIs), the privileged APIs adapted to be accessed by an application with permission to do so. In one variant, the APIs are further adapted to enable handling of events occurring within the apparatus, the events relating to an insufficient amount of available resources of the apparatus, the handling comprises preventing content from being processed by the apparatus.

In another aspect, a method of operating consumer premises equipment (CPE) in operative communication with a content delivery network is disclosed. In one embodiment, the CPE comprising at least at least a privileged first application and a second application, and the method includes: determining if sufficient resources are available for utilization of content to the CPE, and when sufficient resources are not available for the utilization of the content: generating error-related data; selectively initiating at least one action; and storing at least a portion of the error-related data within a storage device.

In another aspect, apparatus adapted for operation within a content distribution network is disclosed. In one embodiment, the apparatus includes: a digital processor; a storage device operatively coupled to the processor; middleware adapted to run on the processor; a software entity adapted to handle resource contentions; and at least one software application adapted to run on the processor. In one variant, the apparatus is further configured, in cooperation with the middleware, to: identify an event relating to resource contention occurring during the operation of the apparatus; and call the software entity to process the resource contention.

In another aspect, consumer premises equipment (CPE) adapted for operation within a content distribution network is disclosed. In one embodiment, the CPE comprises standards-compliant Java-based middleware comprising resource management system and that is adapted to control at least one function within the CPE, and a plurality of software applications. In one variant, the CPE operates according to the method comprising: receiving information relating to a resource contention event from at least one of the plurality of applications; evaluating the resource using the middleware; and in response to the act of evaluating, selectively controlling the operation of one or more of the plurality of applications based at least in part on a prioritization scheme.

In another aspect, apparatus adapted for operation within a content delivery network is disclosed. In one embodiment, the apparatus includes: a network interface adapted for communication with the content delivery network; a digital processor; a storage device operatively coupled to the processor; middleware adapted to run on the processor; and software comprising a plurality of application programming interfaces (APIs), the APIs adapted to be accessed by only an application with permission to do so. In one variant, the APIs are further adapted to enable handling of events occurring within the apparatus, the events relating to an available resource of the apparatus, and the handling comprising removal or destruction of at least one application resident on the apparatus.

In another aspect, apparatus for operation within a hybrid delivery network having both optical fiber and non-fiber portions is disclosed. In one embodiment, the apparatus includes: a network interface in communication with the hybrid delivery network; a digital processor; a storage device operatively coupled to the processor; middleware adapted to run on the processor; and software comprising a plurality of application programming interfaces (APIs), the privileged APIs adapted to be accessed by only an application with permission to do so. In one variant, the APIs are further adapted to enable at least handling of events occurring within the apparatus, the events relating to at least one resource of the apparatus.

These and other aspects of the invention shall become apparent when considered in light of the disclosure provided below.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a functional block diagram illustrating an exemplary HFC network configuration useful with the present invention.

FIG. 1 a is a functional block diagram illustrating one exemplary head-end configuration of an HFC network useful with the present invention.

FIG. 2 is a logical flow diagram illustrating one exemplary embodiment of the event logging and management methodology according to the invention.

FIG. 2 a is a logical flow diagram illustrating an exemplary method of registering for resource exhaustion events using the error logging system of the invention.

FIG. 3 is a functional block diagram of exemplary CPE having the improved error logging and management system.

FIG. 3 a is a logical block diagram illustrating the relationships between the various components within the CPE, and the error logging system.

FIG. 4 is a logical block diagram illustrating the relationships between the various entities associated with the error logging system of the invention.

DETAILED DESCRIPTION OF THE INVENTION

Reference is now made to the drawings wherein like numerals refer to like parts throughout.

As used herein, the term “application” refers generally to a unit of executable software that implements theme-based functionality The themes of applications vary broadly across any number of disciplines and functions (such as e-commerce transactions, brokerage transactions, mortgage interest calculation, home entertainment, calculator etc.), and one application may have more than one theme. The unit of executable software generally runs in a predetermined environment; for example, the unit could comprise a downloadable Java Xlet™ that runs within the JavaTV™ environment.

As used herein, the term “computer program” is meant to include any sequence or human or machine cognizable steps which perform a function. Such program may be rendered in virtually any programming language or environment including, for example, C/C++, Fortran, COBOL, PASCAL, assembly language, markup languages (e.g., HTML, SGML, XML, VoXML), and the like, as well as object-oriented environments such as the Common Object Request Broker Architecture (CORBA), Java™ (including J2ME, Java Beans, etc.) and the like.

As used herein, the term “middleware” refers to software that generally runs primarily at an intermediate layer in a software or protocol stack. For example, middleware may run on top of an operating system and platform hardware, and below applications.

The term “component” refers generally to a unit or portion of executable software that is based on a related set of functionalities. For example, a component could be a single class in Java™ or C++. Similarly, the term “module” refers generally to a loosely coupled yet functionally related set of components.

As used herein, the term “process” refers to executable software that runs within its own CPU environment. This means that the process is scheduled to run based on a time schedule or system event. It will have its own Process Control Block (PCB) that describes it. The PCB will include items such as the call stack location, code location, scheduling priority, etc. The terms “task” and “process” are typically interchangeable with regard to computer programs.

A server process is an executable software process that serves various resources and information to other processes (clients) that request them. The server may send resources to a client unsolicited if the client has previously registered for them, or as the application author dictates.

As used herein, the term “DTV Network Provider” refers to a cable, satellite, or terrestrial network provider having infrastructure required to deliver services including programming and data over those mediums.

As used herein, the terms “network” and “bearer network” refer generally to any type of telecommunications or data network including, without limitation, hybrid fiber coax (HFC) networks, satellite networks, telco networks, and data networks (including MANs, WANs, LANs, WLANs, internets, and intranets). Such networks or portions thereof may utilize any one or more different topologies (e.g., ring, bus, star, loop, etc.), transmission media (e.g., wired/RF cable, RF wireless, millimeter wave, optical, etc.) and/or communications or networking protocols (e.g., SONET, DOCSIS, IEEE Std. 802.3, ATM, X.25, Frame Relay, 3GPP, 3GPP2, WAP, SIP, UDP, FTP, RTP/RTCP, H.323, etc.).

As used herein, the term “head-end” refers generally to a networked system controlled by an operator (e.g., an MSO or multiple systems operator) that distributes programming to MSO clientele using client devices. Such programming may include literally any information source/receiver including, inter alia, free-to-air TV channels, pay TV channels, interactive TV, and the Internet. DSTBs may literally take on any configuration, and can be retail devices meaning that consumers may or may not obtain their DSTBs from the MSO exclusively. Accordingly, it is anticipated that MSO networks may have client devices from multiple vendors, and these client devices will have widely varying hardware capabilities. Multiple regional head-ends may be in the same or different cities.

As used herein, the terms “client device” and “end user device” include, but are not limited to, personal computers (PCs) and minicomputers, whether desktop, laptop, or otherwise, set-top boxes such as the Motorola DCT2XXX/5XXX and Scientific Atlanta Explorer 2XXX/3XXX/4XXX/8XXX series digital devices, personal digital assistants (PDAs) such as the Apple Newton®, “Palm®” family of devices, handheld computers such as the Hitachi “VisionPlate”, personal communicators such as the Motorola Accompli devices, Motorola EVR-8401, J2ME equipped devices, cellular telephones, or literally any other device capable of interchanging data with a network.

Similarly, the terms “Consumer Premises Equipment (CPE)” and “host device” refer to any type of electronic equipment located within a consumer's or user's premises and connected to a network. The term “host device” refers generally to a terminal device that has access to digital television content via a satellite, cable, or terrestrial network. The host device functionality may be integrated into a digital television (DTV) set. The term “consumer premises equipment” (CPE) includes such electronic equipment such as set-top boxes, televisions, Digital Video Recorders (DVR), gateway storage devices (Furnace), and ITV Personal Computers.

As used herein, the term “network agent” refers to any network entity (whether software, firmware, and/or hardware based) adapted to perform one or more specific purposes. For example, a network agent may comprise a computer program running in server belonging to a network operator, which is in communication with one or more processes on a CPE or other device.

As used herein, the term “DOCSIS” refers to any of the existing or planned variants of the Data Over Cable Services Interface Specification, including for example DOCSIS versions 1.0, 1.1 and 2M. DOCSIS (version 1.0) is a standard and protocol for interne access using a “digital” cable network. DOCSIS 1.1 is interoperable with DOCSIS 1.0, and has data rate and latency guarantees (VoIP), as well as improved security compared to DOCSIS 1.0. DOCSIS 2.0 is interoperable with 1.0 and 1.1, yet provides a wider upstream band (6.4 MHz), as well as new modulation formats including TDMA and CDMA. It also provides symmetric services (30 Mbps upstream).

The term “processor” is meant to include any integrated circuit or other electronic device (or collection of devices) capable of performing an operation on at least one instruction including, without limitation, reduced instruction set core (RISC) processors, CISC microprocessors, microcontroller units (MCUs), CISC-based central processing units (CPUs), and digital signal processors (DSPs). The hardware of such devices may be integrated onto a single substrate (e.g., silicon “die”), or distributed among two or more substrates. Furthermore, various functional aspects of the processor may be implemented solely as software or firmware associated with the processor.

Overview

As previously discussed, a network provider such as a cable system operator needs to be able to process events, including identifying (and ideally diagnosing and correcting) any errors that are occurring within consumer premises equipment (CPE) connected to their networks. This CPE may include both leased equipment and retail consumer electronic equipment. Moreover, the ability to communicate with the CPE via the network or other communications channel is useful in handling, and in certain cases obviating, consumer calls and complaints.

The improved event logging and management apparatus and methods described herein provide mechanisms by which the cable system operator or other entity can gain such insight into CPE events and errors (such as those generated by other applications running on the CPE) as well as other operational aspects of the CPE. This substantially enhances the robustness of the CPE and network in general. In an exemplary configuration, an API is provided to trusted downloaded network applications resident on the CPE thereby enabling these applications to discover the error(s), report them to the network operator, and optionally recover from them autonomously or under supervisory control of an external agent. A trusted application such as the monitor application defined by the OCAP 1.0 specification is configured to register with the implementation (a.k.a. middleware) to receive event notifications, such as for example Java exceptions thrown by an application but not caught by the application, and take appropriate action; e.g., reboot in cases where the error was not caused by the monitor application. The error logging system advantageously allows the registered trusted application to store the information received by aforementioned events for retrieval by a network agent where/when convenient for the agent, or where required by another process. In addition, the registered trusted application is optionally programmed by the network operator to generate and deliver one or more error messages or communications of suitable priority. These messages may be of predetermined format/content, or alternatively customized to the particular context of the error experienced by the CPE.

In the context of a typical OCAP-based configuration (e.g., OCAP 1.0), the application manager program within the OCAP system may begin destroying applications, starting with the lowest priority application, when resources (e.g., memory or CPU usage) become exhausted. Exhaustion of system resources may comprise an error (i.e., one type of “event”) that is reportable to the registered trusted application. In another aspect of the invention, a second registration is optionally provided that allows a trusted application to selectively determine which applications are destroyed. Thus, a network application decides which applications are destroyed when system resources are exhausted, rather than the application manager as under the prior art. This approach transfers the recovery control of the exhausted system resources from the CPE manufacturer (via the application manager) to the network operator, thereby providing the network operator with enhanced error recovery capabilities.

Detailed Description of Exemplary Embodiments

Exemplary embodiments of the apparatus and methods of the present invention are now described in detail. While these exemplary embodiments are described in the context of the aforementioned hybrid fiber coax (HFC) cable system architecture having a multiple systems operator (MSO), digital networking capability, and plurality of client devices/CPE, the general principles and advantages of the invention may be extended to other types of networks and architectures, whether broadband, narrowband, wired or wireless, or otherwise, the following therefore being merely exemplary in nature.

It will also be appreciated that while described generally in the context of a consumer (i.e., home) end user domain, the present invention may be readily adapted to other types of environments (e.g., commercial/enterprise, government/military, etc.) as well. Myriad other applications are possible.

FIG. 1 illustrates a typical network component configuration with which the hardware registry apparatus and methods of the present invention may be used. The various components of the network 100 include (i) one or more application origination points 102; (ii) one or more distribution servers 104; and (iii) consumer premises equipment (CPE) 106. The distribution server(s) 104 and CPE(s) 106 are connected via a bearer (e.g., HFC) network 101. A simple architecture comprising one of each of the aforementioned components 102, 104, 106 is shown in FIG. 1 for simplicity, although it will be recognized that comparable architectures with multiple origination points, distribution servers, and/or CPE devices (as well as different network topologies) may be utilized consistent with the invention. For example, the head-end architecture of FIG. 1 a (described in greater detail below) may be used.

The application origination point 102 comprises any medium that allows an application to be transferred to a distribution server 104. This can include for example an application vendor website, CD-ROM, external network interface, mass storage device (e.g., RAID system), etc. Such transference may be automatic, initiated upon the occurrence of one or more specified events (such as the receipt of a request packet or ACK), performed manually, or accomplished in any number of other modes readily recognized by those of ordinary skill.

The distribution server 104 comprises a computer system where one or more applications can enter the network system. Distribution servers are well known in the networking arts, and accordingly not described further herein.

The CPE 106 includes any equipment in the “consumers premises” (or other locations, whether local or remote to the distribution server 104) that can be accessed by a distribution server 104. Such CPEs 106 comprise processors and associated computer memory adapted to store and run the downloaded or resident application. In the present context, at least a portion of the application is typically downloaded to the CPE 106, wherein the latter executes the downloaded application(s)/components, although it will be recognized that all of applications may conceivably be uploaded to the server, or alternatively transferred to another device, such as other networked CPE or the like. Applications may be (i) “pushed” to the CPE (i.e., wherein the distribution server causes the application download to occur), (ii) “pulled” to the CPE (i.e., where the CPE causes the download), (iii) downloaded as the result of some third entity or device (such as a remote server); (iv) resident on the CPE at startup; or (v) combinations of the foregoing.

Referring now to FIG. 1 a, one exemplary embodiment of the network head-end architecture useful with the invention is described. As shown in FIG. 1 a, the head-end architecture 150 comprises typical head-end components and services including billing module 152, subscriber management system (SMS) and CPE configuration management module 154, cable-modem termination system (CMTS) and OOB system 156, as well as LAN(s) 158, 160 placing the various components in data communication with one another. It will be appreciated that while a bar or bus LAN topology is illustrated, any number of other arrangements as previously referenced (e.g., ring, star, etc.) may be used consistent with the invention. It will also be appreciated that the head-end configuration depicted in FIG. 1 a is high-level, conceptual architecture and that each MSO may have multiple head-ends deployed using custom architectures.

The architecture 150 of FIG. 1 a further includes a multiplexer/encrypter/modulator (MEM) 162 coupled to the HFC network 101 adapted to “condition” content for transmission over the network. In the present context, the distribution servers 104 are coupled to the LAN 160, which provides access to the MEM 162 and network 101 via one or more file servers 170. In the typical HFC network, information is carried across multiple channels. Thus, the head-end must be adapted to acquire the information for the carried channels from various sources. Typically, the channels being delivered from the head-end 150 to the CPE 106 (“downstream”) are multiplexed together in the head-end and sent to neighborhood hubs (not shown).

Content (e.g., audio, video, etc.) is provided in each downstream (in-band) channel. To communicate with the head-end, the CPE 106 uses the out-of-band (OOB) or DOCSIS channels and associated protocols. The OCAP 1.0 specification provides for networking protocols both downstream and upstream. To distribute files and applications to the CPE 106, the files and applications are configured as data and object carousels and may be sent in both the in-band and OOB channels. As is well known in the art, a carousel may be viewed as a directory containing files. The files of the carousel utilized herein are sent in a continuous round-robin fashion. If the client device misses a desired or necessary file in one carousel transmission, it can wait for the next. Alternatively, in another embodiment, the CPE portion of the application is configured as part of the program content on a given in-band or DOCSIS channel. As yet another embodiment, the CPE portion is downloaded directly using IP (Internet Protocol) packet traffic in an Out-Of-Band channel. Note that the file carousel or other device providing the application to the CPE 106 via the aforementioned communication channels may be the distribution server 104 previously described, or alternatively a separate device which may or may not be physically co-located with the server (e.g., remote file servers 170 of FIG. 1 a). For example, a remote file storage device (not shown) with carousel capability may be in data communication with the client device(s) via an out-of-band communications channel as described below, the download of the application files from the remote device being initiated by way of a query from the client device, or alternatively a signal generated by the server 104 and transmitted to the remote device. Many other permutations of the foregoing system components and communication methods may also be used consistent with the present invention, as will be recognized by those of ordinary skill in the field.

Referring now to FIG. 2, a first exemplary embodiment of the generalized error logging methodology of the invention is described. As shown in FIG. 2, the first step 202 of the methodology 200 comprises generating a suitable software interface (e.g., application programming interface, or API) adapted to provide access to the error logging services and capabilities described subsequently herein. Software interface generation methods are well known in the art, and accordingly not described further herein. It will be recognized that while the following discussion is cast in terms of traditional forms of APIs (such as those rendered in Java language), other types of interfaces may be utilized.

The software interface generated in step 202 is particularly adapted to provide the CPE to which it is distributed with enhanced error-logging capabilities. This is accomplished via association within an application downloaded or otherwise provided to the CPE, such as a trusted OCAP-compliant monitor application of the type well known in the cable software arts. The trusted application, via the APIs, in effect registers to receive various types of messages and exceptions.

Note that the interface(s) provided with the trusted application may be generic in nature, such as for example one or more APIs having a predetermined configuration or standardization.

Alternatively, the interface(s) may be customized to the particular application or CPE to which it will be distributed. Combinations of standardized and non-standardized/customized APIs may be utilized as well in order to differentiate various services or features within the error logging system.

Per step 204, the API(s) generated in step 202 are distributed to the CPE 106, such as via one or more trusted network applications. For example, OCAP 1.0 specifies that applications are Java-based. OCAP uses the Java-based permission scheme to provide various capabilities to applications in the network. Signed (trusted) applications are capable of receiving permissions in addition to those available to unsigned applications. In addition, an MSO or other entity can selectively assign application permissions to trusted applications of their choice. Monitor application permissions defined by OCAP give an application the ability to perform system level functions such as rebooting the CPE 106.

The distribution of the trusted application/APIs per step 204 may occur directly over a primary content channel of the network, via one or more OOB channels, via an alternate network interface to the CPE (e.g., Internet download via DSL or dial-up connection), or even via hard media such as CD-ROM provided to the CPE user. The API(s) may be delivered with the target “trusted” CPE application, such as at time of configuration of the CPE by the network operator or at time of manufacture, or alternatively delivered subsequently to the CPE after setup, such as in the form of discrete software modules which are appended to or otherwise integrated with the existing target (trusted) application. Hence, the API(s) may be both included in new installations, as well as being retrofit onto older or existing CPE. As will be recognized by those of ordinary skill, myriad different schemes for delivery of the API(s) may be used consistent with the invention described herein.

Lastly, per step 206, the distributed API(s) is/are operated in conjunction with the monitor or other middleware and network to provide error logging, diagnosis, and/or correction capabilities. In one exemplary configuration, the APIs and CPE target application operate only to register and log errors as described in greater detail below. This baseline configuration may be optimal for very “thin” or low-end client devices where only a minimal logging and recovery capability is desired, or where only minimal subscription service options are selected by the consumer (e.g., basic service). Alternatively, more capable API packages and applications may be provided which provide enhanced error logging, diagnosis, and recovery capabilities.

A second registration mechanism is also optionally provided by the invention, whereby the trusted application can be informed when system resources are nearing exhaustion, and make decisions regarding destruction of unnecessary or low priority applications, in order to attempt to recover needed resources (see FIG. 2 a). Additional “intelligence” is programmed into the trusted (e.g., monitor) application, or other software which signals the monitor, to analyze relevant data and identify these conditions or trends. This approach, while ostensibly consuming more resources within the CPE during normal operations (due to increased software overhead resident on the CPE), advantageously allows the monitor or other trusted application to potentially identify trends or other artifacts within resources or running applications, and take appropriate action before an error or other deleterious event is encountered. This approach also provides enhanced continuity of operations for the user and network operator, thereby increasing the satisfaction of the former and the revenue generation of the latter.

In the exemplary method 250 of FIG. 2 a, the trusted application is first registered to receive signaled data relating to resource exhaustion and utilization (step 252). Where the trusted (e.g., monitor) application in the CPE 106 detects an impending exhaustion of memory or CPU via the aforementioned signaling/registration (step 254), it can optionally analyze the data (step 256) and selectively suspend or destroy one or more applications in anticipation of the exhaustion (step 258). This avoids failure or interruption of the in-focus application running on the CPE and presenting a seamless user experience. As described in greater detail subsequently herein, this destruction may occur according to any number of different schemes, such as based on a fixed parameter associated with the application(s) (e.g., application size), a variable parameter associated with the application (e.g., number of resource or service calls issued per unit time), or other static or dynamic prioritization scheme.

The trusted application of the present invention may also be configured with additional intelligence wherein periodic, situational, or deterministic polling of other applications and resources is conducted, and/or corrective actions for error recovery are implemented by the trusted application(s). For example, the trusted application may be configured to recognize situations and/or applications where the likelihood of particular types or errors is increased, and adjust its operational characteristics accordingly. Such recognition may be based on historical data logged by the trusted application (e.g., where a given application or combination of applications has caused a particular type of error in the past), or alternatively on more inductive faculties provided to the monitor (e.g., the analysis and recognition of combinations of two or more parameters or events within the CPE which are known to increase the likelihood of errors).

FIG. 3 illustrates a first embodiment of the improved electronic device with error logging capability according to the present invention. As shown in FIG. 3, the device 300 generally comprises and OpenCable-compliant embedded system having an RF front end 302 (including modulator/demodulator) for interface with the HFC network 101 of FIG. 1, digital processor(s) 304, storage device 306, and a plurality of interfaces 308 (e.g., video/audio interfaces, IEEE-1394 “Firewire”, USB, serial/parallel ports, etc.) for interface with other end-user apparatus such as televisions, personal electronics, computers, WiFi or other network hubs/routers, etc. Other components which may be utilized within the device (deleted from FIG. 3 for simplicity) include RF tuner stages, various processing layers (e.g., DOCSIS MAC, OOB channels, MPEG, etc.) as well as media processors and other specialized SoC or ASIC devices. These additional components and functionality are well known to those of ordinary skill in the cable and embedded system fields, and accordingly not described further herein.

The device 300 of FIG. 3 is also provided with an OCAP 1.0-compliant monitor application and Java-based middleware which, inter alia, manages the operation of the device and applications running thereon. It will be recognized by those of ordinary skill that myriad different device and software architectures may be used consistent with the hardware registry of the invention, the device of FIG. 3 being merely exemplary. For example, different middlewares (e.g., MHP, MHEG, or DASE) may be used in place of the OCAP middleware of the illustrated embodiment.

As previously described, the error logging functionality of the invention is embodied primarily in (i) the device middleware, including APIs specific to the error logging system, (ii) the on-board or remote storage available to the CPE, and (iii) an optional network agent or other entity in communication with the error logger. In the illustrated embodiment (FIG. 3 a), the trusted application 352 is configured to register to receive events 354 such as error messages explicitly sent by a running application 356, Java exceptions and errors thrown (but not caught) by the application, resource depletion events, reboot events not caused by the monitor application 352, or other types of occurrences such as, for example, a “power-on” message. These error messages are received in real-time by the optional event handling agent. If no such agent is registered, the events are dropped. If such an agent is registered it may store the event messages on a storage device for retrieval by a network server agent.

The error logging system 350 allows the registered trusted application 302 to store the information received by such events. The events are stored, for example, in the form of human and/or machine-readable files or records within the storage device 306 disposed on the CPE 106 (e.g., RAM, ROM, memory card, hard drive, etc.), although the data may also be sent or streamed off-CPE to a remote storage location if desired.

The use of human-readable error logs or records within the storage device 306 of the exemplary embodiment advantageously allows an analyst (which may comprise anyone ranging from the consumer to MSO personnel to a third party provider) to rapidly evaluate the type and cause of the error. For example, the human readable data may include the date/time of the event, category of the event, source application or entity, CPE type, a log of other applications running at the time of the event, any recently monitor-initiated reboot events, etc. This aids the analyst in diagnosing the problem rapidly, and instituting corrective action as required. Note that the “analyst” may also comprise a software entity or other process which is adapted to automatically review certain fields within the stored event report, and initiate further actions based thereon. In this latter context, it may none-the-less be desirable to retain the human-readable format in the event that the software analyst is not successful in its resolution.

As used above, the term “other use” may comprise anything ranging from immediate, concurrent use of the information by the monitor or another entity or agent (e.g., another application 362 running on the CPE 106, or a network agent 364) to subsequent use (e.g., transmission via a network agent to the MSO and analysis thereby).

In one exemplary embodiment, the logged data is retrieved by a network agent 364 at a point in time that is convenient or optimal for the network agent or for the network as a whole. For example, periodic polling of connected CPE 106 by a network agent 364 tasked with collecting network-wide error or failure data may be used. As another alternative, an “immediate” approach may be used (e.g., over any available channel, or in conjunction with a carrier access technique such as FDMA, TDMA, ALOHA, or CSMA/CD on an OOB channel), wherein error messages are promptly sent to the network agent, proxy, or other network process when received and processed by the monitor application on the CPE. These event messages may be generated consistent with any number of well-known communications protocols and transmitted via literally any type of communications channels, whether in-band, out-of-band, or completely unrelated to the bearer network. For example, an upstream OOB channel is used in one embodiment to transmit TCP/IP protocol messages. In another embodiment, the CPE 106 is 3G-enabled (e.g., WAP/WTLS or GPRS) and utilizes a wireless CDMA, GSM, or satellite uplink to PSDN or similar infrastructure. Many other alternatives are possible and readily implemented by those of ordinary skill given the present disclosure.

In yet another embodiment, a priority-based approach is implemented wherein the registered trusted application is programmed by the network operator (such programming which may be situationally invoked by the head-end 100, agent 364, or CPE 106 itself) to deliver them according to the priority scheme. Any event logging entity (i.e., application or implementation) sets the event priority when logging an event. For example, a three-tiered classification system may be used which classifies errors or other events as being either “catastrophic”, “recoverable”, or “informational” in nature. It will be recognized that this three-tier system is merely illustrative of the broader concept of a multi-tiered classification approach; any number of different classes and types of event (some which may overlap other classes/types) may be used consistent with the invention. The following exemplary event type range scheme is used in conjunction with the Java code appended hereto to identify and store different event types:

-   -   0x00000000-0x0FFFFFFF—reserved for informational message types;     -   0x10000000-0x1FFFFFFF—reserved for recoverable error types;     -   0x20000000-0x2FFFFFFF—reserved catastrophic error types;     -   0x30000000-0x3FFFFFFF—reserved for reboot events;     -   0x40000000-0x4FFFFFFF—reserved for resource depletion events;         and     -   0x50000000-0xFFFFFFFF—reserved for proprietary use.         Along with an event type code each event logged may include a         human readable string message and in the Java case a String that         indicates a stacktrace of the most recently called methods and         an array of Strings that indicate the class hierarchy of the         error or exception, otherwise known as a Throwable object.

Catastrophic and recoverable events may instigate generation of an immediate message to the network agent or other cognizant entity, while informational events may be issued on an as-available basis, or alternatively bundled into a common message with other informational events (or higher priority “targets of opportunity” concurrently being issued by the monitor) in order to reduce processing overhead and bandwidth consumption. A plethora of different prioritization schemes for various types or errors and events will be readily apparent to those of ordinary skill given the present disclosure.

The foregoing prioritization approach also provides, inter alia, the ability for the agent 362, 364 to apply its own prioritization mask (e.g., message handling algorithm) in dealing with one or more such event messages. Where multiple event messages are received by the cognizant agent in close temporal proximity, such as where a streamed application or content may be adversely affecting a class of CPE or customers for whatever reason, the agent can prioritize action on these messages according to its own mechanisms or those of a parent entity, which may or may not consider the priority of the event message issued by each CPE. For example, one approach handles all events in order of priority and time of message issuance (or receipt) as determined by the message local time stamp; i.e., process all catastrophic events in time-order sequence until exhausted, then process all recoverable alerts in time-order sequence until exhausted, and so forth.

Alternatively, other information can be used within the agent's message handling algorithm in place of or in conjunction with the priority/timing information, such as geographic location, customer subscription class (e.g., basic or “full service”), etc. Similarly, the handling algorithm of the agent may be configured to analyze the content of one or more classes of message (e.g., all catastrophic event messages) immediately upon receipt in order to extract additional data or information as to the nature of the event, such additional data being useful in further prioritizing the events for follow-on action by the agent or its proxy.

It will be recognized that the aforementioned error message handling paradigms may also comprise a multi-tiered or decoupled approach to the actual data transmission. For example, in one exemplary variant, the error logging system 300 of the invention (FIG. 3) is adapted to use short, low-overhead “signaling” messages which are issued by the monitor, or a designated proxy process, to the network agent in lieu of a complete transmission of the logged error data. These signaling messages may be used, for example, to alert the agent as to the existence of an error/event condition (including priority level, if desired) on one or more CPE 106 which has been logged into local storage on the affected CPE.

As will be described in greater detail below, certain errors and events can be handled sufficiently by assets within the CPE 106 itself, thereby not requiring additional intervention by the MSO, user, etc. Accordingly, the improved monitor application described herein (or another associated “local” agent process disposed on the CPE) can in effect pre-process any error messages to (i) log all pertinent data relating to the event for later use; (ii) determine if any corrective action is required; and (iii) determine whether the required corrective action can be effectuated by the monitor application or other resident process. Where additional intervention beyond that which the monitor can provide is required, an event message of the type described above may be issued to the network agent or other comparable entity to initiate such intervention.

Referring now to FIG. 4, the various components of an exemplary error logging system according to the invention are described in greater detail, in the context of a Java-based programming environment. This environment is selected for its ease of programming and implementation, especially in conjunction with the system architecture of FIGS. 3 and 3 a. It will be readily appreciated, however, that the use of Java in this embodiment is merely illustrative; the various logging system components advantageously may be implemented using any one or more different computer languages (including, without limitation C, C++, and Ada), and within various middleware environments (e.g., MHP, OCAP, MHEG, DASE), thereby providing significant flexibility of design. Furthermore, the following discussion illustrates but a sample of the possible constructs within the Java environment that are useful with the broader principles of the invention. For purposes of illustration, other “real-world” issues such as multi-threading have been omitted from the sample code provided herein (Appendices I-XV); however, such issues are readily addressed by those of ordinary skill provided the present disclosure.

As shown in FIG. 4, the error logging system 350 generally consists of the following major components: (i) an event registration entity 402; (ii) an event submission entity 404; (iii) an event database 406; (iv) an emergency event reporting entity 408; (v) a network event retrieval entity 410; and (vi) a resource depletion registration entity 412. These various entities are now discussed in greater detail. It will be recognized that not all of the entities listed above are required for operation of the event logging system 350; rather, various levels of functionality can be achieved by adding more or less of these entities as appropriate. Hence, the system 350 is inherently modular.

Furthermore, it will be appreciated that other types of entities (and configurations of each) may be utilized, the following being merely illustrative of the broader principles.

Event registration entity—This entity 402 comprises a software process which provides the system 350 with a mechanism to register to receive error/event and informational messages from other applications or processes within the CPE 106, including notification of (non-monitor initiated) reboot events, and reason(s) there for. In the exemplary embodiment, it is rendered within the OCAP Implementation using an API.

Appendix I provides code describing an exemplary system registration handler which provides event registration within the system 350.

Appendix II provides exemplary code implementing extensions of system basic permission for the trusted application registering to handle logged events. In OCAP this permission is unnecessary and can be added to the existing monitor application permission class.

Appendix III provides exemplary code implementing the event handler which was registered by the trusted application and called by the implementation when an event is logged.

Appendix IV provides a sample error handling application using the IEventHandler of Appendix III.

Event submission entity—This entity 404 provides the system 350 with the mechanism by which applications may log an error/event message with the system or the registered trusted application. As previously described herein, messages can be logged using any number of different priority schemes (such as the three-tiered catastrophic/recoverable/informational approach). Appendix V provides exemplary Java code implementing an EventProcessor class used for handling event submissions from applications. Appendix VI provides exemplary error event code implementing an error event class. This class represents an event returned by the system when an uncaught exception or error is encountered. Appendix VII provides exemplary code implementing message-based events (e.g., informational, recoverable, catastrophic, reboot, etc.). Appendix VIII provides exemplary code implementing reporting of a reboot event within the CPE (via the IMessageEvent of Appendix VII). Appendix IX provides a sample reboot generating system for generating trusted application (e.g., monitor application) reboot events.

Event Database—The event database 406 comprises in the illustrated embodiment a message database wherein a trusted application may store error and informational messages for retrieval by a network agent or other entity (whether local or remote from the database/CPE). The illustrated database 406 is disposed on the CPE 106 itself, although it will be appreciated that other locations may be used including, for example, other devices within the particular end-user environment, MSO operated networked servers, or even third-party servers or storage facilities. Appendix X provides exemplary Java code implementing a sample error logging application for logging events within the database 406. Appendix XI provides a sample application for handling reboot events, including disposing them within an array of the database 406.

Emergency Event Reporting Entity—This entity 408 comprises a network communications definition for, e.g., immediate delivery of select event/error and informational messages by a trusted application (such as the OCAP-compliant monitor described above) to a network agent or other entity. This provides the system 350 with a rapid mechanism to alert the MSO or another remote entity of impending or existing trouble within the CPE. In the illustrated embodiment, this entity 408 comprises a message system whereby a registered error handler determines that the error or event is critical enough to inform the network agent immediately. A client-server architecture of the type well known in the networking arts is used to implement this system, although other approaches (including the various message distribution and prioritization schemes discussed previously herein) may be substituted with equal success.

Remote Event Retrieval—This entity 410 comprises a (network) communications definition for retrieval of messages in the message database by an agent, the latter which may be internal or external to the CPE 106, such as a remote network agent. This is to be contrasted with the emergency reporting entity 408, which is tasked with issuing alerts of one form or another to the agent. As with the emergency event reporting entity 408, the event retrieval entity 410 of the exemplary embodiment comprises a client-server based message system whereby the agent polls clients based on, e.g., a round-robin schedule arranged to minimize network impact, or any other selected scheme as previously described herein. Hence, this entity 410 provides access to stored data and records of the CPE irrespective of their priority.

Resource Depletion Registration Entity—This entity 412 comprises a mechanism to register to receive messages regarding the incipient exhaustion of system resources such as memory and CPU bandwidth. As discussed previously herein, a variety of different schemes may be used to determine (i) proximity (in time or another parameter) to an exhaustion event; (ii) the priority associated with any data or messages received by the mechanism 412; and (iii) the corrective actions to be initiated in response to the message. For example, where impending memory exhaustion is detected (such as through periodic or situational comparison of data representing the current available memory to the total or nominal memory capacity of the CPE), a message will be issued to the depletion registration entity 412 indicating the same. Depending on how emergent the need for action is, the message may be coded as to priority level; e.g., low, medium, or high priority. The depletion entity 412, upon receipt of the message, may be configured to selectively destroy running applications according to a secondary priority scheme (which may, for example, be dictated by the monitor application running on the CPE 106 or another entity in communication with the CPE 106); e.g., destroy applications according to a particular sequence or hierarchy, such as largest first, non “in-focus” first, etc. Myriad other schemes are possible. The MHP and OCAP standards, for example, specify functionality that provides an application destruction hierarchy which may be used with the invention.

Appendix XII provides exemplary Java code implementing the notification (i.e., in the form of a ResourceDepletionEvent class) within the system when a resource depletion event occurs. Appendices XIII and XIV provide code illustrating exemplary resource depletion event generating systems and resource depletion event handling applications, respectively.

Appendix XV provides exemplary code implementing the class for testing of the reboot, event (error), and depletion handlers.

In addition to the foregoing, the event logging system of the present invention is also optionally provided with other functional entities which perform various purposes within the system relating to error/event handling. Specifically, a trusted application priority entity (not shown) is optionally provided to indicate to the system 400 that the trusted application shall handle near-exhaustion events, and that the system handlers of such events should provide no handling of such events. In the case of the attached exemplary code, the act of registering for depletion event receipt (by the depletion entity 412) performs this task as well. Alternatively, these functions may also be separated so that an application can register to receive the event messages, but not be required to act upon them, other than to record the event and perhaps send it to a network agent or other entity (“record and relay” function).

The error logging system of the present invention can also advantageously be used without interfering with other functions resident in the CPE, such as for example the hardware registry described in co-owned and co-pending U.S. patent application Ser. No. 10/723,959 Nov. 24, 2003 and entitled “METHODS AND APPARATUS FOR HARDWARE REGISTRATION IN A NETWORK DEVICE”, incorporated herein by reference in its entirety. For example, events or errors generated through access or manipulation of the hardware registry and its various associated options (such as a hardware failure or contention deadlock) can be stored and accessed as desired by a network agent in order to troubleshoot such errors, and potentially obviate service calls relating thereto.

It will be recognized that while certain aspects of the invention are described in terms of a specific sequence of steps of a method, these descriptions are only illustrative of the broader methods of the invention, and may be modified as required by the particular application. Certain steps may be rendered unnecessary or optional under certain circumstances. Additionally, certain steps or functionality may be added to the disclosed embodiments, or the order of performance of two or more steps permuted. All such variations are considered to be encompassed within the invention disclosed and claimed herein.

While the above detailed description has shown, described, and pointed out novel features of the invention as applied to various embodiments, it will be understood that various omissions, substitutions, and changes in the form and details of the device or process illustrated may be made by those skilled in the art without departing from the invention. The foregoing description is of the best mode presently contemplated of carrying out the invention. This description is in no way meant to be limiting, but rather should be taken as illustrative of the general principles of the invention. The scope of the invention should be determined with reference to the claims.

APPENDIX I - SYSTEM HANDLER REGISTRAR © Copyright 2003 Time Warner Cable, Inc. All rights reserved. import java.lang.*; import java.security.*; /**  * Registration mechanism for trusted applications to set the error handler.  */ public class SysHandlerRegistrar {  public final static int ERROR_INFO_EVENT_HANDLER = 0x0;  public final static int REBOOT_EVENT_HANDLER = 0x1;  public final static int RESOURCE_DEPLETION_EVENT_HANDLER = 0x2;  private static SysHandlerRegistrar theSHR = null;  private static IEventHandler theErrorInfoEventHandler = null;  private static IEventHandler theRebootEventHandler = null;  private static IEventHandler theResourceDepletionHandler = null;  /**   * Zero argument constructor is protected so an application cannot create it.   */  protected SysHandlerRegistrar( )  {  }  /**   * Get the singleton instance of the system handler registrar.   *   * @param type - ERROR_INFO_EVENT_HANDLER, REBOOT_EVENT_HANDLER, or   * RESOURCE_DEPLETION_HANDLER.   *   * @return The system handler registrar.   */  public static SysHandlerRegistrar getInstanceo  {   if(theSHR == null)    theSHR = new SysHandlerRegistrar( );   return theSHR;  }  /**   * Get the system system handler.   *   * @param type - ERROR_INFO_EVENT_HANDLER, REBOOT_EVENT_HANDLER, or   * RESOURCE_DEPLETION_HANDLER.   *   * @return Currently registered handler for the type specified.   *   * @throws SysHandlerPermission if the application does not have permission   * to get the handler.   */  public static IEventHandler getEventHandler(int type) throws SecurityException  {   SysHandlerPermission ehp = new SysHandlerPcmission(“getEventHandler”);   // If the caller does not have permission the AccessController will throw a   // SecurityException.   //AccessController.checkPermission(ehp); to be uncommented   if(type == ERROR_INFO_EVENT_HANDLER)    return theErrorInfoEventHandler;   else    if(type == REBOOT_EVENT_HANDLER)     return theRebootEventHandler;    else     return theResourceDepletionHandler;  }  /**   * Set the system event handler.   *   * @param type - ERROR_INFO__EVENT_HANDLER, REBOOT_EVENT_HANDLER, or   * RESOURCE_DEPLETION_HANDLER.   *   * @param seh - System event handler created by the registering application.   *   * @throws EventHandlerPermission if the application does not have permission   * to set the handler.   */  public static void setEventHandler(int type, IEventHandler seh) throws SecurityException  {   SysHandlerPermission ehp = new SysliandlerPermission(“setEventHandler”);   // If the caller does not have permission the AccessController will throw a   // SecurityException.   //AccessController.checkPermission(ehp); to be uncommented   if(type == ERROR_INFO_EVENT_HANDLER)     theErrorInfoEventHandler = seh;   else     if(type == REBOOT_EVENT_HANDLER)     theRebootEventHandler = seh;     else     theResourceDepletionHandler = seh;  }  /**   * Unset the system event handler.   *   * @param type - ERROR_INFO_EVENT_HANDLER, REBOOT_EVENT_HANDLER, or   * RESOURCE_DEPLETION_HANDLER.   *   * @throws EventHandlerPermission if the application does not have permission   * to unset the handler.   */  public static void unsetEventHandler(int type) throws SecurityException  {   SysHandlerPermission ehp = new SysHandlerPermission(“setEventHandler”);   // If the caller does not have permission the AccessController will throw a   // SecurityException.   //AccessController.checkPermission(ehp); to be uncommented   if(type == ERROR_INFO_EVENT_HANDLER)     theErrorInfoEventHandler = null;   else     if(type == REBOOT_EVENT_HANDLER)     theRebootEventHandler = null;     else     theResourceDepletionHandler = null;  } }

APPENDIX II - SYSTEM HANDLER PERMISSION © Copyright 2003 Time Warner Cable, Inc. All rights reserved. import java.security.*; public final class SysHandlerPermission extends BasicPermission {  public SysHandlerPermission(String permissionName)  {   super(permissionName);  }  public SysHandlerPermission(String permissionName, String actions)  {   super(permissionName, actions);  } }

APPENDIX III - IEVENT HANDLER © Copyright 2003 Time Warner Cable, Inc. All rights reserved. /**  * Event handler implemented by a trusted application and registered with  * EventHandlerRegistrar.  */ public interface IEventHandler {   /**    * The system will call this method when an error/info/reboot event is incurred and a    * trusted application has registered to receive them.    *    * @param see - event encountered by the middleware.    *    * @return If the registered application will completely handle this event, null is returned,    * otherwise the event can be modified or returned unchanged and the system will    * handle it.    */   public IMessageEvent receiveEvent(IMessageEvent see);   /**    * Get any events saved by the handler.    *    * @return The array of events or null if none were stored.    */   public IMessageEvent [ ] getEvents( ); }

APPENDIX IV - ERROR HANDLING APPLICATION © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class ErrorHandlingAppSample implements IEventHandler {  private final static int MAX_EVENT_STORE = 5;  private final static int ID_FOR_APP_SAMPLE = 55; // typically set by the system  private static int eventCount = 0;  private IMessageEvent [ ] imeStore = new IMessageEvent[MAX_EVENT_STORE];  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event.   */  public ErrorHandlingAppSample( )  {   // Get the default system error handier registrar.   SysHandlerRegistrar ehr =     SysHandlerRegistrar.getInstance( );   // Set this object as the new error handler.   ehr.setEventHandler(SysHandlerRegistrar.ERROR_INFO_EVENT_HANDLER, this);  }  /**   * Receive a message event from, the EventProcessor. This method will be used to process   * all of the error and informational messages sent to the registered error handler and   * other applications. This sample simply places the messages into an array. Additional   * processing is specific to the application. For example, an application may look at   * the error code and application identifier of the event and take recovery action for   * specific errors. In case of a critical error the handler may send a message to a   * server agent.   *   * @param see - Event generated by the system or sent by an application.   *   * @return The event unchanged, or the event modified to suit the purposes of the   * registered registered event handler, or null to indicate that the registered handler   * has consumed the event.   */  public IMessageEvent receiveEvent(IMessageEvent see)  {   System.out.print(“ErrorHandlingAppSample.receiveEvent( ); event type: ”);   System.out.print(see.getTypeCode( ));   System.out.print(“; date: ”);   System.out.println(see.getDate( ));   eventCount = (eventCount == MAX_EVENT_STORE − 1) ? 0 : eventCount + 1;   imeStore[eventCount] = see; // Store the event for later retrieval.   return null;  // Tell the EventDatabase that the registered handler has consumed        // the event.  }  /**   * Get any events saved by the handler. A network server agent may poll a client agent   * running in the same device as this handler so that the client agent can get the   * events using this method.   *   * @return The array of events or null if none were stored.   */  public IMessageEvent [ ] getEvents( )  {   return imeStore;  } }

APPENDIX V - EVENT PROCESSOR © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class EventProcessor {   // The singleton event database.   private static EventProcessor el = null;   // Get the event handler   private static SysHandlerRegistrar ehr =      SysHandlerRegistrar.getInstance( );   private static IEventHandler seh = null;   private EventProcessor( )   {   }   public static EventProcessor getInstance( )   {    if(el == null)     el = new EventProcessor( );    return el;   }   public static IMessageEvent log(IMessageEvent meIn)   {    IMessageEvent me = meIn;    if(me instanceof ErrorEvent) {     if((seh = ehr.getEventHandler(SysHandlerRegistrar.ERROR_INFO_EVENT_HANDLER)) != null)      me = seh.receiveEvent(meIn);     else      System.out.println(me.getDate( ));    }    else if(me instanceof RebootEvent) {     if((seh = ehr.getEventHandler(SysHandlerRegistrar.REBOOT_EVENT_HANDLER)) != null)      me = seh.receiveEvent(meIn);     else      System.out.println(me.getDate( ));  }  else {     if((seh = ehr.getEventHandler(         SysHandlerRegistrar.RESOURCE_DEPLETION_EVENT_HANDLER)) != null)      me = seh.receiveEvent(meIn);     else      System.out.println(me.getDate( ));     }     return me;  }                         }

APPENDIX VI - ERROR EVENT © Copyright 2003 Time Warner Cable, Inc. All rights reserved. import java.lang.*; import java.util.*; /** */ public class ErrorEvent implements IMessageEvent {  public final static int INFO_SHUTDOWN_IMMINENT = 0x0;  public final static int ERROR_UNCAUGHT_JAVA_EXCEPTION = 0X30000001;  // Static error event Id number. Incremented for each new event.  private static long lastEventId;  private long eventId;  private long appId;  private int typeCode;  private long date;  private String message;  private Throwable errorOrException;  /**   * Three argument ErrorEvent constructor.   *   * @param typeCodeIn - The value indicating the error; see IMessageEvent.   *   * @param errorMsg - The readable error message in the following format:   */  public ErrorEvent(int typeCodeIn, long appIdIn, String messageIn)  {   this(typeCodeIn, appIdIn, messageIn, null);  }  /**   * Four argument ErrorEvent constructor.   *   * @param errorType - The value indicating the error; see IMessageEvent.   *   * @param errorMsg - The readable error message in the following format:   */  public ErrorEvent(int typeCodeIn,       long appIdIn,       String messageIn,       Throwable errorOrExceptionIn)  {   lastEventId = (lastEventId == Long.MAX_VALUE) ? 0 : lastEventId + 1;   eventId = lastEventId;   typeCode = typeCodeIn;   date = System.currentTimeMillis( );   message = messageIn;   errorOrException = errorOrExceptionIn;  }  /**   * Get the unique identifier of the event.   *   * @return unique identifier of the event.   */  public long getEventId( )  {   return eventId;  }  /**   * Get the unique identifier of the application that logged the event.   *   * @return The application identifier.   */  public long getAppId( )  {   return appId;  }  /**   * Get the event type code. Identifies a code specific to the event system.   *   * @return type code of the event.   */  public int getTypeCode( )  {   return typeCode;  }  /**   * Set the error type code. Allows an application to change the error received.   *   * @param error - The new error value.   */  public void setTypeCode(int typeCodeIn)  {   typeCode = typeCodeIn;  }  /**   * Get the event date in milli-seconds from midnight January 1, 1970.   *   * @return Date the event was submitted to the system.   */  public long getDate( )  {   return date;  }  /**   * Set the date. Allows an application to change the date received.   *   * @param error - The new error value.   */  public void setDate(long dateIn)  {   date = dateIn;  }  /**   * Get the readable message.   *   * @return the readable event message.   */  public String getMessage( )  {   return message;  }  /**   * Set the error message string. Allows an application to change the error message received.   *   * @param error - The new error message.   */  public void setErrorMessage(String messageIn)  {   message = messageIn;  }  protected void finalize( )  {   // Store the lastErrorEventId in a persistent storage object.  }  static {   if(/*some persistent storage object exists with error event Id stored in it*/ true)    lastEventId = /* value in the persistent storage object */1;   else    lastEventId = 0;  } }

APPENDIX VII - IMESSAGE EVENT © Copyright 2003 Time Warner Cable, Inc, All rights reserved. public interface IMessageEvent {  /*   * 0x00000000-0x0FFFFFFF are reserved for informational message types,   * 0x10000000-0x1FFFFFFF are reserved for recoverable error types,   * 0x20000000-0x2FFFFFFF are reserved catastrophic error types,   * 0x30000000-0x3FFFFFFF are reserved for reboot events,   * 0x40000000-0x4FFFFFFF are reserved for resource depletion events,   * 0x50000000-0xFFFFFFFF are reserved for proprietary use,   */  /**   * Get the unique identifier of the event.   *   * @return unique identifier of the event.   */  public long getEventId( );  /**   * Get the unique identifier of the application logging the event.   *   * @return The identifier of the application.   */  public long getAppId( );  /**   * Get the event type code. Identifies a code specific to the event system.   *   * @return type code of the event.   */  public int getTypeCode( );  /**   * Get the event date in milli-seconds from midnight January 1, 1970.   *   * @return Date the event was submitted to the system.   */ public long getDate( );

APPENDIX VIII - REBOOT EVENT © Copyright 2003 Time Warner Cable, Inc. All rights reserved. import java.lang.*; public class RebootEvent implements IMessageEvent {  public final static int REBOOT_BUTTON_PRESSED = 0x30000001;  public final static int REBOOT_BY_IMPLEMENTATION = 0x30000002;  public final static int REBOOT_BY_TRUSTED_APP = 0x30000003;  public final static int REBOOT_FOR_UNHANDLED_SYS_ERROR = 0x30000004;  public final static int REBOOT_FOR_UNHANDLED_APP_ERROR = 0x30000005;  // Static reboot event Id number. Incremented for each new event.  private static long lastEventId;  private long eventId;  private long appId;  private int typeCode;  private long date;  private String message;  public RebootEvent(int typeCodeIn, tong appIdIn, String messageIn)  {   lastEventId = (lastEventId == Long.MAX_VALUE) ? 0 : lastEventId + 1;   eventId = lastEventId;   typeCode = typeCodeIn;   appId = appIdIn;   date = System.currentTimeMillis( );   message = messageIn;  }  /**   * Get the unique identifier of the event.   *   * @return unique identifier of the event.   */  public long getEventId( )  {   return eventId;  }  /**   * Get the unique identifier of the application logging the event.   *   * @return The application identifier.   */  public long getAppId( )  {   return eventId;  }  /**   * Get the event type code. Identifies a code specific to the event system.   *   * @return type code of the event.   */  public int getTypeCode( )  {   return typeCode;  }  /**   * Set the error type code. Allows an application to change the error received.   *   * @param error - The new error value.   */  public void setTypeCode(int typeCodeIn)  {   typeCode = typeCodeIn;  }  /**   * Get the event date in milli-seconds from midnight January 1, 1970,   *   * @return Date the event was submitted to the system.   */  public long getDate( )  {   return date;  }  /**   * Set the date. Allows an application to change the date received.   *   * @param error - The new error value.   */  public void setDate(long dateIn)  {   date = dateIn;  }  /**   * Get the readable message.   *   * @return the readable event message.   */  public String getMessage( )  {   return message;  }  protected void finalize( )  {   // Store the lastRebootEventId in a persistent storage object.  static {   if(/*some persistent storage object exists with reboot event Id stored in it*/ true)    lastEventId = /* value in the persistent storage object */I;   else    lastEventId = 0;  } }

APPENDIX IX - REBOOT GENERATING SYSTEM © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class RebootGeneratingSysSample {  private final static int ID_FOR_APP_SAMPLE = 55; // typically set by the system  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event,   */  public RebootGeneratingSysSample( )  {   // Create an error event.   RebootEvent re = new RebootEvent(RebootEvent.REBOOT_BY_IMPLEMENTATION, 0, “TestReboot”);   // Get the default system event logger.   EventProcessor ep = EventProcessor.getInstance( );   for(int i = 0; i < 5; i++) {    // Log an error to the default system error handler.    ep.log(re);    re.setDate(System.currentTimeMillis( ));    re.setTypeCode(re.getTypeCode( ) + 1);    try    {     Thread.sleep(500);    }    catch (InterruptedException ie)    {    }   }  } }

APPENDIX X - ERROR LOGGING APP © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class ErrorLoggingAppSample {  private final static int ID_FOR_APP_SAMPLE = 55; // typically set by the system  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event.   */  public ErrorLoggingAppSample( )  {   // Create an error event.   ErrorEvent see = new ErrorEvent(ErrorEvent.ERROR_UNCAUGHT_JAVA_EXCEPTION, ID_FOR_APP_SAMPLE, “TestEvent”);   // Get the default system event logger.   EventProcessor el = EventProcessor.getInstance( );   for(int i = 0; i < 5; i++) {    // Log an error to the default system error handler.    el.log(see);    see.setDate(System.currentTimeMillis( ));    see.setTypeCode(see.getTypeCode( ) + 1);    try    {     Thread.sleep(500);    }    catch (InterruptedException ie)    {    }   }  } }

APPENDIX XI - REBOOT HANDLING © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class RebootHandlingAppSample implements IEventHandler {  private final static int MAX_EVENT_STORE = 5;  private final static int ID_FOR_APP_SAMPLE = 55; // typically set by the system  private static int eventCount = 0;  private IMessageEvent [ ] imeStore = new IMessageEvent[MAX_EVENT_STORE];  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event.   */  public RebootHandlingAppSample( )  {   // Get the default system error handler registrar.   SysHandlerRegistrar ehr =     SysHandlerRegistrangetInstance( );   // Set this object as the new reboot handier.   ehr.setEventHandler(SysHandlerRegistrar.REBOOT_EVENT_HANDLER, this);  }  /**   * Receive a message event from the EventProcessor. This method will be used to process   * all of the reboot messages sent to the registered error handler by the system.   * This sample simply places the messages into an array. Additional processing is   * specific to the application. For example, an application may look at   * the reboot code of the event and take action for specific types of reboots. In case   * of a critical or recurring reboot problem the handler may send a message to a   * server agent.   *   * @param see - Event generated by the system or sent by an application.   *   * @return The event unchanged, or the event modified to suit the purposes of the   * registered registered event handler, or null to indicate that the registered handler   * has consumed the event.   */  public IMessageEvent receiveEvent(IMessageEvent see)  {   System.out.print(“RebootHandlingAppSample.receiveEvent( ); event type: ”);   System.out.prinksee.getTypeCode( ));   System.out.print(“; date: ”);   System.out.printIn(see.getDate( ));   eventCount = (eventCount == MAX_EVENT_STORE − 1) ? 0 : eventCount + 1;   imeStore[eventCount] = see;  // Store the event for later retrieval.   return null;  // Tell the EventDatabase that the registered handler has consumed // the event.  }  /**   * Get any events saved by the handler. A network server agent may poll a client agent   * running in the same device as this handler so that the client agent can get the   * events using this method.   *   * @return The array of events or null if none were stored.   */  public IMessageEvent [ ] getEvents( )  {   return imeStore;  } }

APPENDIX XII - RESOURCE DEPLETION EVENT © Copyright 2003 Time Warner Cable, Inc. All rights reserved. import java.lang.*; import java.util.*; /**  * Event returned by the system when an uncaught exception or error is encountered.  */ public class ResourceDepletionEvent implements IMessageEvent {  public final static int RESOURCE_SYS_MEM_DEPLETED = 0X40000001 ;  public final static int RESOURCE_CPU_BANDWIDTH_DEPLETED = 0X40000002;  public final static int RESOURCE_OUT_OF_SYS_MEM = 0X40000100;  // Static error event Id number. Incremented for each new event.  private static long lastEventId;  private long eventId;  private long appId;  private int typeCode;  private long date;  private String message;  /**   * Create a SystemErrorEvent.   *   * @param errorType - The value indicating the error; see IMessageEvent.   *   * @param errorMsg - The readable error message in the following format:   */  public ResourceDepletionEvent(int typeCodeIn, long appIdIn, String messageIn)  {   lastEventId = (lastEventId == Long.MAX_VALUE) ? 0 : lastEventId + 1;   eventId = lastEventId;   typeCode = typeCodeIn;   date = System.currentTimeMillis( );   message = messageIn;  {  /**   * Get the unique identifier of the event.   *   * @return unique identifier of the event.   */  public long getEventId( )  {   return eventId;  }  /**   * Get the unique identifier of the application that logged the event.   *   * @return The application identifier.   */  public long getAppId( )  {   return appId;  {  /**   * Get the event type code. Identifies a code specific to the event system.   *   * @return type code of the event.   */  public int getTypeCode( )  {   return typeCode;  }  /**   * Set the error type code. Allows an application to change the error received.   *   * @param error - The new error value.   */  public void setTypeCode(int typeCodeIn)  {   typeCode = typeCodeIn;  }  /**   * Get the event date in milli-seconds from midnight January 1, 1970.   *   * @return Date the event was submitted to the system.   */  public long getDate( )  {   return date;  }  /**   * Set the date. Allows an application to change the date received.   *   * @param error - The new error value.   */  public void setDate(long dateIn)  {   date = dateIn;  }  /**   * Get the readable message.   *   * @return the readable event message.   */  public String getMessage( )  {   return message;  }  /**   * Set the error message string. Allows an application to change the error message received.   *   * @param error - The new error message.   */  public void setErrorMessage(String messageIn)  {   message = messageIn;  }  protected void finalize( )  {   // Store the lastErrorEventId in a persistent storage object.  }  static {   if(/*some persistent storage object exists with error event Id stored in it*/ true)    lastEventId = /* value in the persistent storage object */l;   else    lastEventId = 0;  } }

APPENDIX XIII - RESOURCE DEPLETION EVENT GENERATING SYSTEM © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class ResourceDepletionEventGeneratingSysSample {  private final static int ID_FOR_APP_SAMPLE = 55;  // typically set by the system  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event.   */  public ResourceDepletionEventGeneratingSysSample( )  {   // Create an error event.   ResourceDepletionEvent rde = new ResourceDepletionEvent( ResourceDepletionEvent.RESOURCE_OUT_OF_SYS_MEM, 0, “TestReboot”);   // Get the default system event logger.   EventProcessor ep = EventProcessor.getInstance( );   for(int i = 0; i < 5; i++) {    // Log an error to the default system error handler.    ep.log(rde);    rde.setDate(System.currentTimeMillis( ));    rde.setTypeCode(rde.getTypeCode( ) + 1);    try    {     Thread.sleep(500);    }    catch (InterruptedException ie)    {    }   } } }

APPENDIX XIV - RESOURCE DEPLETION EVENT HANDLING APPLICATION © Copyright 2003 Time Warner Cable, Inc. All rights reserved. public class ResourceDepletionEventHandlingAppSample implements IEventHandler {  private final static int MAX_EVENT_STORE = 5;  private final static int ID_FOR_APP_SAMPLE = 55; // typically set by the system  private static int eventCount = 0;  private IMessageEvent [ ] imeStore = new IMessageEvent[MAX_EVENT_STORE];  /**   * The zero argument constructor demonstrates a possible application example where   * the application registers to receive error events, logs events, and registers to   * receive reboot events. The SysSample class contains that code that will generate   * a sample reboot event.   */  public ResourceDepletionEventHandlingAppSample( )  {   // Get the default system error handler registrar.   SysHandlerRegistrar ehr =     SysHandlerRegistrar.getInstance( );   // Set this object as the new reboot handler.   ehr.setEventHandler(SysHandlerRegistrar.RESOURCE_DEPLETION_EVENT_HANDLER, this);  }  /**   * Receive a message event from the EventProcessor. This method will be used to process   * all of the resource depletion messages sent to the registered error handler by the system.   * This sample simply places the messages into an array. Additional processing is   * specific to the application. An application may look at the resource depletion   * code of the event and take action for specific types of events. For example; if the   * system is running out of memory the handler may kill low priority applications in an   * effort to get some back. The same might be true for CPU bandwidth. In case of a   * critical error the handler may send a message to a server agent.   *   * @param see - Event generated by the system or sent by an application.   *   * @return The event unchanged, or the event modified to suit the purposes of the   * registered registered event handler, or null to indicate that the registered handler   * has consumed the event.   */  public IMessageEvent receiveEvent(IMessageEvent see)  {   System.out.print(“ResourceDepletionEventHandlingAppSample.receiveEvent( ); event type: ”);   System.out.print(see.getTypeCode( ));   System.out.print(“; date: ”);   Systentout.println(see.getDate( ));   eventCount = (eventCount == MAX_EVENT_STORE − 1) ? 0 : eventCount + 1;   imeStore[eventCount] = see; // Store the event for later retrieval.   return null;  // Tell the EventDatabase that the registered handler has consumed // the event.  }  /**   * Get any events saved by the handler. A network server agent may poll a client agent   * running in the same device as this handler so that the client agent can get the   * events using this method.   *   * @return The array of events or null if none were stored.   */  public IMessageEvent [ ] getEvents( )  {   return imeStore;  } }

APPENDIX XV - TEST ERROR APPLICATION © Copyright 2003 Time Warner Cable, Inc. All rights reserved. /**  * Main class for testing the reboot, error, and resource depletion handlers. Note that all  * can be registered for in the same manner.  */ public class TestErrorApp {  public static void main(String [ ] args)  {   RebootHandlingAppSample rhas = new RebootHandlingAppSample( );   RebootGeneratingSysSample rgss = new RebootGeneratingSysSample( );   ErrorHandlingAppSample ehas = new ErrorHandlingAppSample( );   ErrorLoggingAppSample elan = new ErrorLoggingAppSample( );   ResourceDepletionEventHandlingAppSample rdhas = new ResourceDepletionEventHandlingAppSample( );   ResourceDepletionEventGeneratingSysSample rdgss = new ResourceDepletionEventGeneratingSysSample( );  } } 

What is claimed is:
 1. Apparatus adapted for operation with a content delivery network, said apparatus comprising: a network interface adapted for communication with said content delivery network; a digital processor; a storage device operatively coupled to said processor; middleware adapted to run on said processor; and software comprising a plurality of application programming interfaces (APIs), said APIs comprising privileged APIs which are configured to be accessed by an application with permission to do so; wherein said APIs are further configured to, when an insufficient amount of available resources of said apparatus are detected, prevent content from being processed by said apparatus.
 2. The apparatus of claim 1, wherein said content delivery network comprises an Internet-based delivery network.
 3. The apparatus of claim 1, wherein said APIs comprise Java-based classes and methods.
 4. The apparatus of claim 1, wherein said application with permission comprises a monitor application.
 5. The apparatus of claim 1, wherein said APIs are further configured to, generate a notification message of said prevention of said content processing.
 6. The apparatus of claim 5, wherein said notification message comprises information relating to said event and is provided to said content delivery network.
 7. A method of operating consumer premises equipment (CPE) in operative communication with a content delivery network, said CPE comprising at least at least a privileged first application and a second application, said method comprising: determining whether sufficient resources are available for utilization for delivery of content to said CPE, and when sufficient resources are not available: generating error-related data; selectively initiating at least one action; and storing at least a portion of said error-related data within a storage device.
 8. The method of claim 7, wherein: said acts of generating and selectively initiating are performed at least in part by said privileged first application; and wherein said act of determining is performed at least in part by said second application.
 9. The method of claim 8, wherein said content delivery network comprises a non-managed network.
 10. The method of claim 7, wherein said at least one action comprises preventing said delivery of said content.
 11. The method of claim 10, wherein said at least one action further comprises causing sufficient resources to become available.
 12. The method of claim 7, further comprising in response to receiving a periodic communication from said network, providing said error-related data thereto.
 13. The method of claim 7, further comprising notifying the content delivery network of an occurrence of at least one error.
 14. Apparatus adapted for operation within a content distribution network, said apparatus comprising: a digital processor; a storage device operatively coupled to said processor; middleware adapted to run on said processor; a software entity adapted to handle resource contentions; and at least one software application adapted to run on said processor; wherein said apparatus is further configured, in cooperation with said middleware, to: identify an event relating to resource contention occurring during the operation of said apparatus; and call said software entity to process said resource contention.
 15. The apparatus of claim 14, wherein said content distribution network comprises a managed network operated by a network operator.
 16. The apparatus of claim 14, wherein said content distribution network comprises an managed internetwork.
 17. The apparatus of claim 14, wherein said software entity is associated with a trusted monitor application of said apparatus.
 18. The apparatus of claim 14, wherein said at least one software application comprises a resource contention resolution application, and said software entity is adapted to cooperate with said resolution application to resolve said resource contention.
 19. The apparatus of claim 14, further comprising an event submission entity, said submission entity comprising a software process adapted to permit said at least one application to log an error or event message.
 20. The apparatus of claim 19, wherein said event submission entity is adapted to permit said at least one application to log an error or event message with a trusted application associated with said software entity.
 21. The apparatus of claim 19, further comprising an event registration entity, said registration entity adapted to register to receive at least one of error, event and informational messages from other applications or processes within said apparatus.
 22. Consumer premises equipment (CPE) configured for operation within a content distribution network, said CPE comprising standards-compliant Java-based middleware comprising resource management system, said middleware being configured to control at least one function within said CPE, said CPE further comprising a plurality of software applications, and said CPE operating according to a method comprising: receiving information relating to a resource contention event from at least one of said plurality of applications; evaluating said resource using said middleware; and in response to said act of evaluating, selectively controlling operation of one or more of said plurality of applications based at least in part on a prioritization scheme.
 23. The CPE of claim 22, wherein said controlling the operation comprises removal or destruction of at least one of said applications.
 24. The CPE of claim 22, further comprising a monitor application, and said CPE is further adapted to interface with a network entity, said network entity comprising a software component disposed external to said CPE.
 25. The CPE of claim 22, wherein at least a portion of said plurality of applications are downloaded to said CPE from time to time via an external network interface.
 26. The CPE of claim 22, wherein said middleware is adapted to be at least partly controlled by an external entity, said external entity comprising a head-end supervisory process or its proxy.
 27. Apparatus configured for operation within a content delivery network, said apparatus comprising: a network interface configured for communication with said content delivery network; a digital processor; a storage device operatively coupled to said processor; middleware configured to run on said processor; and software comprising a plurality of application programming interfaces (APIs), said APIs configured to be accessed by only an application with permission to do so; wherein said APIs are further configured to when a resource of said apparatus is identified as unavailable, remove or destroy at least one application resident on said apparatus.
 28. The apparatus of claim 27, wherein said removal or destruction of at least one application comprises removal or destruction according to a hierarchy or priority scheme.
 29. The apparatus of claim 28, wherein said hierarchy or priority scheme comprises an MHP-compliant destruction hierarchy or scheme or an OCAP-compliant destruction hierarchy or scheme.
 30. The apparatus of claim 27, wherein said content delivery network comprises a satellite delivery network or an unmanaged internetwork.
 31. Apparatus for operation within a hybrid delivery network having both optical fiber and non-fiber portions, said apparatus comprising: a network interface in communication with said hybrid delivery network; a digital processor; a storage device operatively coupled to said processor; middleware adapted to run on said processor; and software comprising a plurality of application programming interfaces (APIs), said privileged APIs adapted to be accessed by only an application with permission to do so; wherein said APIs are further adapted to enable at least handling of events occurring within said apparatus, said events relating to at least one resource of said apparatus.
 32. A method of operating client equipment in operative communication with a hybrid optical fiber and non-fiber delivery network, said equipment comprising at least at least a privileged first application and a second application, said method comprising: detecting at least one error in the operation of said client equipment; determining a type of said at least one detected error; and selectively initiating at least one action based at least in part on said determined type; wherein said acts of determining and selectively initiating are performed at least in part by said privileged first application; and wherein said act of detecting is performed at least in part by said second application.
 33. The method of claim 32, wherein said at least one detected error comprises either a hardware failure event or a contention event.
 34. The method of claim 32, further comprising generating and storing data relating to said error. 